;;; Upper CYC(R) Ontology flat-file ;;; Copyright Cycorp 1997. All rights reserved. ;;;Cycorp License Agreement ;;;Cycorp is providing this material from the Cyc(tm) Upper ;;;Ontology at no charge, for everyone to use, including ;;;commercial service use and incorporation into products. ;;;However, it is not 'Public Domain.' Please acknowledge ;;;Cycorp, 3721 Executive Center Dr., Austin, TX 78731 in ;;;any use or citation of this material, and request that each ;;;further user include a full copy of this notice as well, ;;;in any use or citation they make of the material. All ;;;these terms equally apply to renamings and other ;;;logically equivalent reformulations of the material in ;;;any natural or formal language. Cycorp intends to ;;;amend and expand the material from time to time; the ;;;latest version is available at http://www.cyc.com ;;; #$inverseRelationTypeMin (#$isa #$inverseRelationTypeMin #$QuaternaryPredicate) (#$arg1Isa #$inverseRelationTypeMin #$BinaryPredicate) (#$arg2Isa #$inverseRelationTypeMin #$Collection) (#$arg3Isa #$inverseRelationTypeMin #$Collection) (#$arg4Isa #$inverseRelationTypeMin #$NonNegativeInteger) (#$comment #$inverseRelationTypeMin "(#$inverseRelationTypeMin SLOT COL1 COL2 NUM) means that, for every instance of COL2 (INS2) there are at least NUM instances of COL1 (INS1, INS3, ...) such that (SLOT INS1 INS2), (SLOT INS3 INS2), ..., hold. Thus (#$inverseRelationTypeMin #$children #$Person #$HumanChild 1) means literally `every child is the child of at least one person' or `every child has at least one parent'.") ;;; #$isa (#$not (#$isa #$isa #$IrreflexiveBinaryPredicate)) (#$not (#$isa #$isa #$ReflexiveBinaryPredicate)) (#$not (#$isa #$isa #$TransitiveBinaryPredicate)) (#$isa #$isa #$TaxonomicSlotForAnyUnit) (#$isa #$isa #$DefaultMonotonicPredicate) (#$isa #$isa #$BinaryPredicate) (#$genlPreds #$isa #$elementOf) (#$arg1Isa #$isa #$ReifiableTerm) (#$arg2Isa #$isa #$Collection) (#$comment #$isa "(#$isa EL COL) means that EL is an element of the collection COL. Cyc knows that #$isa distributes over #$genls; that is, if one asserts (#$isa EL COL) and (#$genls COL SUPER), Cyc will infer that (#$isa EL SUPER). Therefore, in practice one only manually asserts a small fraction of the #$isa assertions --- the vast majority are inferred automatically by Cyc.") (#$overlappingExternalConcept #$isa #$SENSUS-Information1997 "CLASS-ASCRIPTION") ;;; #$isolatedNodeInSystem (#$isa #$isolatedNodeInSystem #$AsymmetricBinaryPredicate) (#$genlPreds #$isolatedNodeInSystem #$pointInSystem) (#$arg1Isa #$isolatedNodeInSystem #$Thing) (#$arg2Isa #$isolatedNodeInSystem #$Thing) (#$comment #$isolatedNodeInSystem "(#$isolatedNodeInSystem X SYS) means that the node X in the #$PathSystem SYS is an isolated point in SYS, i.e., X is not on any link or loop in the #$PathSystem SYS. Note that an isolated point must be a node in SYS.") ;;; #$ist (#$isa #$ist #$MicrotheoryPredicate) (#$isa #$ist #$BinaryPredicate) (#$arg1Isa #$ist #$Microtheory) (#$arg2Isa #$ist #$CycFormula) (#$comment #$ist "(#$ist MICRO PROP) means that the Cyc assertion PROP is true in the Cyc #$Microtheory MICRO. E.g., one might assert (#$ist Image8093Mt (#$age #$Lenat (#$YearsDuration 5)) to state that in the context of a certain photograph, Doug was 5 years old. In other microtheories, Doug would have different ages, or not be `known about' at all.") ;;; #$ist-Agreement (#$isa #$ist-Agreement #$BinaryPredicate) (#$isa #$ist-Agreement #$MicrotheoryPredicate) (#$genlPreds #$ist-Agreement #$ist) (#$arg1Isa #$ist-Agreement #$Agreement) (#$arg2Isa #$ist-Agreement #$CycFormula) (#$comment #$ist-Agreement "The predicate #$ist-Agreement is used to indicate the propositions which have been agreed upon in a particular agreement. (#$ist-Agreement AGR PROP) means that the proposition PROP is and should be true, according to the #$Agreement AGR. PROP is expressed as a #$CycFormula and is considered true within the microtheory which represents AGR. PROP may or may not be true in reality. Note the distinction between #$ist and #$ist-Agreement: #$ist relates any particular microtheory to all assertions that happen to be true in that microtheory; but #$ist-Agreement specially indicates those assertions in an #$Agreement microtheory which belong to the agreement itself and are not just something that happens to be true in it (e.g., that one of the #$agreeingAgents is named Joe).") ;;; #$ist-Information (#$isa #$ist-Information #$BinaryPredicate) (#$isa #$ist-Information #$MicrotheoryPredicate) (#$genlPreds #$ist-Information #$ist) (#$arg1Isa #$ist-Information #$PropositionalInformationThing) (#$arg2Isa #$ist-Information #$CycFormula) (#$comment #$ist-Information "This is a form of #$ist that applies to the explicit content of a chunk of information. It is needed so we can distinguish between things that are true in an information context because they were explicitly stated, and things that are true because they can be inferred.") ;;; #$itemWorn (#$isa #$itemWorn #$BinaryPredicate) (#$isa #$itemWorn #$Role) (#$arg1Isa #$itemWorn #$WearingSomething) (#$arg2Isa #$itemWorn #$SomethingToWear) (#$comment #$itemWorn "The predicate #$itemWorn is used to indicate a particular article of clothing (or other wearable item) that is worn in a particular situation. (#$itemWorn WEARING ITEM) means that ITEM is the #$ClothingItem worn during the situation WEARING, an element of #$WearingSomething (q.v.).") ;;; #$jobAttributes (#$isa #$jobAttributes #$IntangibleObjectPredicate) (#$isa #$jobAttributes #$BinaryPredicate) (#$arg1Isa #$jobAttributes #$OccupationType) (#$arg2Isa #$jobAttributes #$JobAttribute) (#$comment #$jobAttributes "The predicate #$jobAttributes describes a type of job as #$BlueCollar, #$WhiteCollar, #$Unionized, etc. (#$jobAttributes JOBTYPE ATTRIBUTE) means that ATTRIBUTE describes a general property of the #$OccupationType JOBTYPE. Note that this predicate talks about elements of #$OccupationType (kinds of occupations), not about a particular job held by some individual.") ;;; #$judicialAgents (#$isa #$judicialAgents #$IrreflexiveBinaryPredicate) (#$isa #$judicialAgents #$AsymmetricBinaryPredicate) (#$isa #$judicialAgents #$ActorSlot) (#$genlPreds #$judicialAgents #$mediators) (#$arg1Isa #$judicialAgents #$SocialOccurrence) (#$arg2Isa #$judicialAgents #$Agent) (#$comment #$judicialAgents "(#$judicialAgents EV JUDGE) means that the #$Agent JUDGE is acting as a judge in the event EV.") ;;; #$junctionInSystem (#$isa #$junctionInSystem #$AsymmetricBinaryPredicate) (#$genlPreds #$junctionInSystem #$pointInSystem) (#$arg1Isa #$junctionInSystem #$Thing) (#$arg2Isa #$junctionInSystem #$Thing) (#$comment #$junctionInSystem "(#$junctionInSystem JUNCTION SYS) means that JUNCTION is a junction in the #$PathSystem SYS, i.e., a node in SYS that is an 'intersection' or 'branching point' of links or loops in SYS. (For the case when no SYS is specified, see #$JunctionOfPaths.) Formally, a node X in SYS is a junction in SYS iff either there are three (different) links in SYS such that X is on all of them, or there are two (different) loops in SYS such that X is on both of them, or there is a link in SYS and there is a loop in SYS such that X is on both of them. For different kinds of junctions in a path system, see #$threeWayJunctionInSystem, #$fourWayJunctionInSystem.") ;;; #$knows (#$isa #$knows #$PropositionalAttitudeSlot) (#$genlPreds #$knows #$beliefs) (#$arg1Isa #$knows #$IntelligentAgent) (#$arg2Isa #$knows #$CycFormula) (#$comment #$knows "(#$knows AGT PROP) means that the #$Agent AGT believes the proposition PROP (represented by a #$CycFormula), is sure about the truth of PROP (may or may not have a rational argument for PROP), and furthermore PROP is in fact true at least in the current context (#$Microtheory). Note: Knowledge is stronger than belief; it implies belief. So if (#$knows AGT PROP), then (#$beliefs AGT PROP) is true. Note: Knowledge is stronger than truth; it implies truth (in the current #$Microtheory): if (#$knows AGT PROP), then PROP is true. Note: Opinion and knowledge are mutually exclusive: if (#$knows AGT PROP), then it is NOT true that (#$opinions AGT PROP). Note: Knowledge implies awareness. Since Abraham Lincoln died a century before we were born, it is impossible for (#$knows #$AbrahamLincoln (#$likesAsFriend #$Lenat #$MaryShepherd)) to hold, except in some fictional context. ") (#$overlappingExternalConcept #$knows #$SENSUS-Information1997 "KNOW") ;;; #$knowsAbout (#$isa #$knowsAbout #$BinaryPredicate) (#$not (#$isa #$knowsAbout #$TransitiveBinaryPredicate)) (#$not (#$isa #$knowsAbout #$SymmetricBinaryPredicate)) (#$not (#$isa #$knowsAbout #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$knowsAbout #$AsymmetricBinaryPredicate)) (#$not (#$isa #$knowsAbout #$ReflexiveBinaryPredicate)) (#$not (#$isa #$knowsAbout #$IrreflexiveBinaryPredicate)) (#$arg1Isa #$knowsAbout #$IntelligentAgent) (#$arg2Isa #$knowsAbout #$Thing) (#$comment #$knowsAbout "(#$knowsAbout AGT X) means that the #$IntelligentAgent AGT knows something about X. This predicate represents more than simple awareness, but exactly what is known -- the content of AGT's knowledge about X -- is not specified. Examples: (#$knowsAbout #$Lenat #$Cyc), (#$knowsAbout #$MichaelJordan #$BasketBallGame). Note: many commonsense rules can conclude (#$knowsAbout AGT X) -- e.g., those having to do with AGT's occupation, college degrees, city of residence,... in fact, almost any assertion about AGT can lead to presumptions that he/she probably #$knowsAbout something. #$knowsAbout in turn can serve (weakly) in arguments about whether or not AGT #$knows (qv) specific common assertions involving X, and in arguments about whether or not AGT #$knowsValue of some particular predicate applied to X, etc.") ;;; #$knowsValue (#$isa #$knowsValue #$ModalRelationship) (#$isa #$knowsValue #$TernaryPredicate) (#$arg1Isa #$knowsValue #$IntelligentAgent) (#$arg2Isa #$knowsValue #$Thing) (#$arg3Isa #$knowsValue #$BinaryPredicate) (#$comment #$knowsValue "(#$knowsValue AGT X PRED) means that, if (PRED X VAL) is true, then the #$Agent ?AGT knows that; i.e., (#$knows AGT (PRED X VAL)). E.g., this is a more compact way of expressing `people know their own date of birth' than if one had to use #$knows. One could just write (#$implies (#$isa ?A #$Agent) (#$knowsValue ?A ?A #$birthDate); presumably this would be asserted in a context (#$Microtheory) in which all actions were performed by human beings, or else there would have to be an extra qualifier to that effect added to the rule.") ;;; #$languageOfCommunication (#$isa #$languageOfCommunication #$Role) (#$isa #$languageOfCommunication #$FunctionalSlot) (#$arg1Isa #$languageOfCommunication #$Communicating) (#$arg2Isa #$languageOfCommunication #$Language) (#$comment #$languageOfCommunication "The predicate #$languageOfCommunication is used to indicate a language used by agents in a particular communication event. (#$languageOfCommunication COM LANG) means that in the #$Communicating COM, the information transferred is expressed in the language LANG. LANG may be a natural language, a computer language, a musical system, or other symbolic system such as #$AmericanSignLanguage.") ;;; #$languageSpoken (#$isa #$languageSpoken #$BinaryPredicate) (#$genlPreds #$languageSpoken #$hasCommConvention) (#$genlPreds #$languageSpoken #$knowsAbout) (#$arg1Isa #$languageSpoken #$IntelligentAgent) (#$arg2Isa #$languageSpoken #$NaturalLanguage) (#$comment #$languageSpoken "(#$languageSpoken INTAGENT NATLANG) means the #$IntelligentAgent INTAGENT speaks the natural human language NATLANG at least somewhat fluently. The language must be speakable by humans, as are English, Latin, or Japanese, but not LISP, C or LINCOS. So, for example, (#$languageSpoken #$Lenat #$EnglishLanguage). See #$NaturalLanguage.") ;;; #$lastName (#$isa #$lastName #$BinaryPredicate) (#$isa #$lastName #$IntangibleObjectPredicate) (#$genlPreds #$lastName #$nameOfAgent) (#$arg1Isa #$lastName #$Person) (#$arg2Isa #$lastName #$HumanFamilyNameString) (#$comment #$lastName "(#$lastName X STRNG) means that #$Person X is known by the #$HumanFamilyNameString STRNG as his or her last name (surname). E.g., (#$lastName #$Lenat ``Lenat''). A person rarely has more than one last name at any one time. Last names may change as a result of certain actions, such as marriages, deaths, etc., in various cultures.") ;;; #$lastSubEvents (#$isa #$lastSubEvents #$SubProcessSlot) (#$genlPreds #$lastSubEvents #$subEvents) (#$genlPreds #$lastSubEvents #$temporallyFinishedBy) (#$arg1Isa #$lastSubEvents #$Event) (#$arg2Isa #$lastSubEvents #$Event) (#$comment #$lastSubEvents "(#$lastSubEvents ?X ?Y) implies (#$subEvents ?X ?Y) and (#$temporallyFinishedBy ?X ?Y). For example, one Cyc axiom says that if ?X is a #$WagingWar event, and (#$lastSubEvents ?X ?Y) is true, and ?Y is a #$Surrendering event, then the the identity of those for whom the war was #$successfulForAgents can be inferred from the particular roles that are played by the various parties during the surrender. This is how one might infer, from Lee surrendering to Grant, that the South lost the American Civil War.") ;;; #$laterSubAbstractions (#$isa #$laterSubAbstractions #$AsymmetricBinaryPredicate) (#$isa #$laterSubAbstractions #$TransitiveBinaryPredicate) (#$isa #$laterSubAbstractions #$ComplexTemporalRelation) (#$arg1Isa #$laterSubAbstractions #$SomethingExisting) (#$arg2Isa #$laterSubAbstractions #$SomethingExisting) (#$comment #$laterSubAbstractions "(#$laterSubAbstractions SUB1 SUB2) means that SUB1 and SUB2 are both a #$subAbstrac of the same entity (i.e., (#$hasSameEntityAs SUB1 SUB2)) and the sub-abstraction SUB2 starts sometime after the beginning of SUB1 (i.e., (#$startsAfterStartingOf SUB2 SUB1)). For example, #$RichardFeynman while working on the Manhattan Project was a #$laterSubAbstractions than #$RichardFeynman in his first year of graduate school at Princeton.") ;;; #$laterThan (#$isa #$laterThan #$AsymmetricBinaryPredicate) (#$isa #$laterThan #$TransitiveBinaryPredicate) (#$isa #$laterThan #$EvaluatableFunction) (#$arg1Isa #$laterThan #$Date) (#$arg2Isa #$laterThan #$Date) (#$comment #$laterThan "#$laterThan is similar to #$greaterThan, but takes #$Dates as arguments. (#$laterThan DATE1 DATE2) is true when DATE1 and DATE2 are #$Dates, and DATE1 starts after DATE2 is over. #$laterThan is evaluatable.") ;;; #$laws (#$isa #$laws #$CotemporalObjectsSlot) (#$genlPreds #$laws #$cotemporal) (#$arg1Isa #$laws #$GeopoliticalEntity) (#$arg2Isa #$laws #$GovernmentCOC) (#$comment #$laws "The predicate #$laws is used to relate a geopolitical region (country, state, city, etc.) to a law or entire legal code which applies there. (#$laws GEOPOL CODE) means that the #$GeopoliticalEntity GEOPOL officially has the law (or set of laws) CODE. See also #$GovernmentCOC for the representation of a #$Law or a #$LegalCode as a #$Microtheory.") ;;; #$legallyCapableOf (#$isa #$legallyCapableOf #$TernaryPredicate) (#$arg1Isa #$legallyCapableOf #$Agent) (#$arg2Isa #$legallyCapableOf #$Collection) (#$arg2Genl #$legallyCapableOf #$Situation) (#$arg3Isa #$legallyCapableOf #$Role) (#$comment #$legallyCapableOf "The predicate #$legallyCapableOf indicates that an agent is legally able to take a certain role in a certain type of action. (#$legallyCapableOf AGT SIT-TYPE ROLE) means that the individual AGT is legally qualified and/or entitled to act in this ROLE in #$Situations of the type SIT-TYPE. For example, a person over 21 years of age is #$legallyCapableOf smoking cigarettes in the United States.") ;;; #$lengthOfObject (#$isa #$lengthOfObject #$PhysicalAmountSlot) (#$genlPreds #$lengthOfObject (#$MeaningInSystemFn #$SENSUS-Information1997 "LINEAR-SIZE")) (#$genlPreds #$lengthOfObject (#$MeaningInSystemFn #$SENSUS-Information1997 "SIZE-PROPERTY-ASCRIPTION")) (#$arg1Isa #$lengthOfObject #$SpatialThing) (#$arg2Isa #$lengthOfObject #$Distance) (#$comment #$lengthOfObject "(#$lengthOfObject OBJ LEN) means that the tangible object OBJ has a length LEN. Which dimension counts as length depends upon the object's orientation (which may be intrinsic or determined relative to its environment).") ;;; #$levelWith (#$isa #$levelWith #$TransitiveBinaryPredicate) (#$isa #$levelWith #$ReflexiveBinaryPredicate) (#$isa #$levelWith #$SpatialPredicate) (#$isa #$levelWith #$SymmetricBinaryPredicate) (#$genlInverse #$levelWith #$levelWith) (#$arg1Isa #$levelWith #$PartiallyTangible) (#$arg2Isa #$levelWith #$PartiallyTangible) (#$comment #$levelWith "(#$levelWith OBJ1 OBJ2) means that OBJ1 and OBJ2 are roughly the same vertical distance from some horizontal surface in the frame of reference.") ;;; #$lightSource (#$isa #$lightSource #$TernaryPredicate) (#$arg1Isa #$lightSource #$PartiallyTangible) (#$arg2Isa #$lightSource #$PartiallyTangible) (#$arg3Isa #$lightSource #$IlluminationModeAttribute) (#$comment #$lightSource "The predicate #$lightSource is used to indicate the source of an illumination falling on a particular object. (#$lightSource OBJ SOURCE MODE) means that OBJ is illuminated by SOURCE with the type of illumination (#$IlluminationModeAttribute) MODE.") ;;; #$likesAsFriend (#$isa #$likesAsFriend #$BinaryPredicate) (#$not (#$isa #$likesAsFriend #$TransitiveBinaryPredicate)) (#$not (#$isa #$likesAsFriend #$SymmetricBinaryPredicate)) (#$not (#$isa #$likesAsFriend #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$likesAsFriend #$AsymmetricBinaryPredicate)) (#$not (#$isa #$likesAsFriend #$ReflexiveBinaryPredicate)) (#$not (#$isa #$likesAsFriend #$IrreflexiveBinaryPredicate)) (#$genlPreds #$likesAsFriend #$likesObject) (#$genlPreds #$likesAsFriend #$acquaintedWith) (#$arg1Isa #$likesAsFriend #$Animal) (#$arg2Isa #$likesAsFriend #$Animal) (#$comment #$likesAsFriend "(#$likesAsFriend AGT1 AGT2) means that AGT1 enjoys interacting socially with AGT2. See also the #$FeelingAttributeTypes #$Friendliness. Note: this predicate does not imply that AGT1 likes AGT2 only as a friend -- there may be romantic feelings, and other feelings, as well.") ;;; #$likesObject (#$not (#$isa #$likesObject #$IrreflexiveBinaryPredicate)) (#$not (#$isa #$likesObject #$ReflexiveBinaryPredicate)) (#$not (#$isa #$likesObject #$AsymmetricBinaryPredicate)) (#$not (#$isa #$likesObject #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$likesObject #$SymmetricBinaryPredicate)) (#$not (#$isa #$likesObject #$TransitiveBinaryPredicate)) (#$isa #$likesObject #$BinaryPredicate) (#$arg1Isa #$likesObject #$Animal) (#$arg2Isa #$likesObject #$PartiallyTangible) (#$comment #$likesObject "(#$likesObject AGT OBJ) means that when the sentient agent AGT is interacting in some way with OBJ, that agent feels some measure of #$Enjoyment --- that is, (#$feelsEmotion AGT #$Enjoyment). The kind of interactions that produce #$Enjoyment depend largely on what kind of thing OBJ is. Thus, `Joe likes the Mona Lisa' implies that Joe feels #$Enjoyment when viewing the Mona Lisa. But `Joe likes pizza' implies that Joe feels #$Enjoyment when eating that kind of food. There are some specialized predicates of #$likesObject that give more information about the kind of interaction between AGT and OBJ that results in #$Enjoyment; see, e.g., #$likesSensorially and #$likesAsFriend.") ;;; #$likesRoleInActivity (#$isa #$likesRoleInActivity #$TernaryPredicate) (#$arg1Isa #$likesRoleInActivity #$Agent) (#$arg2Isa #$likesRoleInActivity #$ActorSlot) (#$arg3Isa #$likesRoleInActivity #$Event) (#$comment #$likesRoleInActivity "(#$likesRoleInActivity AGT ROLE EVT) means that if the #$Agent AGT has the relation ROLE to the #$Event EVT, then AGT is likely to feel some positive measure of #$Enjoyment. This predicate is useful to represent sentences such as `Joe likes running' or `Fred liked receiving the money'.") ;;; #$likesSensorially (#$not (#$isa #$likesSensorially #$IrreflexiveBinaryPredicate)) (#$not (#$isa #$likesSensorially #$ReflexiveBinaryPredicate)) (#$not (#$isa #$likesSensorially #$AsymmetricBinaryPredicate)) (#$not (#$isa #$likesSensorially #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$likesSensorially #$SymmetricBinaryPredicate)) (#$not (#$isa #$likesSensorially #$TransitiveBinaryPredicate)) (#$isa #$likesSensorially #$BinaryPredicate) (#$arg1Isa #$likesSensorially #$PerceptualAgent) (#$arg2Isa #$likesSensorially #$SensoryAttribute) (#$comment #$likesSensorially "(#$likesSensorially AGT SENSUM) means that the #$PerceptualAgent AGT derives some physical pleasure from the sensory experience of SENSUM (a taste, odor, or other #$SensoryAttribute).") ;;; #$linkBetweenInSystem (#$isa #$linkBetweenInSystem #$QuaternaryPredicate) (#$arg1Isa #$linkBetweenInSystem #$Path-Simple) (#$arg2Isa #$linkBetweenInSystem #$Thing) (#$arg3Isa #$linkBetweenInSystem #$Thing) (#$arg4Isa #$linkBetweenInSystem #$Thing) (#$comment #$linkBetweenInSystem "(#$linkBetweenInSystem LINK X Y SYS) means that in the #$PathSystem SYS, LINK (a link in SYS) has its two end points X and Y (nodes in SYS). A link in a path system is one of the paths in the system whose end points are nodes in the system and that have no other nodes along them. For each link LINK in SYS, there is a unique pair {X, Y} of different nodes in SYS such that (#$linkBetweenInSystem LINK X Y SYS) and (#$linkBetweenInSystem LINK Y X SYS) hold, and for two points (nodes) in SYS, there could be several different ('parallel') links between them. No point in SYS that is not a node can be an end point of a link. If node X is an end-point of LINK and (#$linkBetweenInSystem LINK X Y SYS) holds, then (#$pointOnPath X LINK) holds. A link in SYS may have many points on it other than its end-points, but these points cannot be nodes in SYS (another way to put this is to say that there are exactly two nodes on a link, though there can be any number, greater than 1, of points on the link). Only nodes in SYS can be 'intersection' point in SYS (see #$junctionInSystem), which implies that there is, in the system SYS, no point on a link LINK between X and Y that is an 'intersection' point of LINK and another link or a loop. When defining a path system, it is convenient (and also quite safe) to start with a name of the system, say SYS1 (with an assertion (#$isa SYS1 #$PathSystem)), and enter the names of links in SYS, say Link1, Link2 etc. (with assertions (#$isa Link1 #$Path-Simple) etc.), and then only enter assertions of the form (#$linkBetweenInSystem LINK X Y SYS1) for each link in SYS1 and its end points X and Y--the rules related to a path systems will generate assertions like (#$nodeInSystem X SYS1), (#$pointInSystem X SYS1), (#$linkInSystem LINK SYS1) and (#$pathInSystem LINK SYS1) etc. If one later needs to add something else to the system, say a point A on a link LINK other than its end nodes X and Y, he/she may further enter (#$betweenOnPath A X Y LINK) and (#$pointInSystem A SYS1) without changing anything else. Note that (#$linkBetweenInSystem LINK X Y SYS) is actually an abbreviation of (#$and (#$linkInSystem LINK SYS) (#$nodeInSystem X SYS) (#$nodeInSystem Y SYS) (#$pathBetween LINK X Y)).") ;;; #$linkClosedSubSystems (#$isa #$linkClosedSubSystems #$ReflexiveBinaryPredicate) (#$isa #$linkClosedSubSystems #$TransitiveBinaryPredicate) (#$isa #$linkClosedSubSystems #$AntiSymmetricBinaryPredicate) (#$genlPreds #$linkClosedSubSystems #$subPathSystems) (#$arg1Isa #$linkClosedSubSystems #$Thing) (#$arg2Isa #$linkClosedSubSystems #$Thing) (#$comment #$linkClosedSubSystems "(#$linkClosedSubSystems SYS SUBSYS) means that the path system SUBSYS is a subsystem of the path system SYS (i.e., (#$subPathSystems SYS SUBSYS) holds) and SUBSYS 'preserves' all links in SYS between nodes in SUBSYS, i.e., if (#$linkBetweenInSystem LINK X Y SYS) holds and X and Y are in SUBSYS, LINK is a link in SUBSYS.") ;;; #$linkInSystem (#$isa #$linkInSystem #$AsymmetricBinaryPredicate) (#$arg1Isa #$linkInSystem #$Path-Simple) (#$arg2Isa #$linkInSystem #$Thing) (#$comment #$linkInSystem "(#$linkInSystem LINK SYS) means that LINK is an instance of #$Path-Simple taken as a primitive path (called a link) in the #$PathSystem SYS. For each link LINK in a path system SYS, there is a unique pair {X, Y} of different nodes in SYS (see #$nodeInSystem) such that X and Y are the two end-points of LINK in SYS. Other 'points' can also be on LINK, but they cannot be nodes in SYS. There can be no point on a link that is different from its end points but nevertheless on another link, i.e., no matter how many points there are on a particular link in a path system, none of them can be an 'intersection' (see #$junctionInSystem) except the end points of the link, which are nodes in the system. See #$linkBetweenInSystem. Each link in SYS is also a path in SYS, i.e., (#$linkInSystem LINK SYS) implies (#$pathInSystem LINK SYS). Note that there is no general collection of all links. Any path can be a link if you can somehow ignore the intersection points on it--it all depends on the #$PathSystem.") ;;; #$lispDefun (#$isa #$lispDefun #$BinaryPredicate) (#$isa #$lispDefun #$FunctionalSlot) (#$isa #$lispDefun #$RelationshipPredicate) (#$arg1Isa #$lispDefun #$EvaluatableFunction) (#$arg2Isa #$lispDefun #$CycSystemSymbol) (#$comment #$lispDefun "The Cyc predicate #$lispDefun is used to relate an evaluatable Cyc function to the name of the piece of code that is used to evaluate it. (#$lispDefun E-FUN NAME) means that the #$CycSystemSymbol NAME is the name of a piece of Heuristic Level (SubL) code in the Cyc system which is used to compute the value of expressions containing the #$EvaluatableFunction E-FUN.") ;;; #$litigants (#$isa #$litigants #$IrreflexiveBinaryPredicate) (#$isa #$litigants #$AsymmetricBinaryPredicate) (#$isa #$litigants #$ActorSlot) (#$genlPreds #$litigants #$socialParticipants) (#$arg1Isa #$litigants #$Trial) (#$arg2Isa #$litigants #$Agent) (#$comment #$litigants "(litigants ARG1 ARG2) means that the agent ARG2 is one of the contending parties in the lawsuit ARG1.") ;;; #$loopInSystem (#$isa #$loopInSystem #$AsymmetricBinaryPredicate) (#$genlPreds #$loopInSystem #$cycleInSystem) (#$arg1Isa #$loopInSystem #$Path-Generic) (#$arg2Isa #$loopInSystem #$Thing) (#$comment #$loopInSystem "(#$loopInSystem LOOP SYS) means that LOOP is a 'loop' in SYS, which is like a link in SYS except that it has exactly one node on it as if it is a link whose two end nodes are the same. Each loop in SYS is also a cycle in SYS, see #$cycleInSystem. The differences between a loop and a (non-loop) cycle in SYS include that (i) there is exactly one point in SYS on a loop (which must be a node in SYS), but there may in general be any finite number of nodes (and even as many points as there are real numbers) on some (non-loop) cycle in SYS, and that (ii) The unique node in SYS on a loop may or may not be an end point of a link in SYS, but each node on a (non-loop) cycle in SYS must be an end point of at least two links in SYS. These imply that there can be at most one 'intersection point' on a loop in SYS but there can be any finite number of 'intersection points' on a (non-loop) cycle in SYS. See #$pointOnCycle and #$junctionInSystem. Note that under current treatment of loops in a path system, if one would like to talk about a 'loop' in a path system a 'part' of which is a path in the system, then he/she should make it a cycle rather than a loop in the system because according to what we said above, no 'part' of a loop in the system can be presented as a path in the system.") ;;; #$loves (#$isa #$loves #$BinaryPredicate) (#$not (#$isa #$loves #$TransitiveBinaryPredicate)) (#$not (#$isa #$loves #$SymmetricBinaryPredicate)) (#$not (#$isa #$loves #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$loves #$AsymmetricBinaryPredicate)) (#$not (#$isa #$loves #$ReflexiveBinaryPredicate)) (#$not (#$isa #$loves #$IrreflexiveBinaryPredicate)) (#$genlPreds #$loves #$likesAsFriend) (#$genlPreds #$loves #$positiveVestedInterest) (#$arg1Isa #$loves #$Animal) (#$arg2Isa #$loves #$Agent) (#$comment #$loves "(#$loves AGENT1 AGENT2) means AGENT1 loves AGENT2; AGENT2 has a strong emotional affect on AGENT1 whereby AGENT1 is usually loyal and devoted to and wishes well AGENT2, seeks AGENT2's companionship, and will incur substantial personal cost to help AGENT2. Any #$Agent can love any other #$Agent, though there are specialized types of love which are restricted to two animals, two adult people, two corporations, a person and a corporation, etc.") ;;; #$madeBy (#$isa #$madeBy #$BinaryPredicate) (#$arg1Isa #$madeBy #$Product) (#$arg2Isa #$madeBy #$CommercialOrganization) (#$comment #$madeBy "The predicate #$madeBy was used to indicate that a particular product was made by a particular company. (#$madeBy PROD COMORG) means that PROD, an individual instance of #$Product, was manufactured by the #$CommercialOrganization COMORG. Cf. #$makesProductType.") ;;; #$mainConstituent (#$isa #$mainConstituent #$CompositionPredicate) (#$isa #$mainConstituent #$FunctionalSlot) (#$isa #$mainConstituent #$CotemporalObjectsSlot) (#$not (#$isa #$mainConstituent #$TransitiveBinaryPredicate)) (#$genlPreds #$mainConstituent #$constituents) (#$genlPreds #$mainConstituent #$cotemporal) (#$arg1Isa #$mainConstituent #$PartiallyTangible) (#$arg2Isa #$mainConstituent #$PartiallyTangible) (#$comment #$mainConstituent "The predicate #$mainConstituent is used to indicate the most significant portion of an element of #$ExistingStuffType that makes up a particular #$PartiallyTangible thing. (#$mainConstituent X Y) means that X's #$constituents include Y, and (as a default) the physical properties of the thing X are those of its main constituent, Y. For example, for a particular instance of #$Lemonade, there is an instance of #$Water which is the #$mainConstituent, and most of the physical properties of the #$Lemonade derive from #$Water. On the other hand, a person is NOT considered to have some portion of #$Water as #$mainConstituent, even though much of a person's mass is #$Water, because the physical properties of a person are not the same as those of water.") ;;; #$mainProduct (#$not (#$isa #$mainProduct #$IrreflexiveBinaryPredicate)) (#$not (#$isa #$mainProduct #$ReflexiveBinaryPredicate)) (#$isa #$mainProduct #$TransitiveBinaryPredicate) (#$isa #$mainProduct #$AntiSymmetricBinaryPredicate) (#$isa #$mainProduct #$PartPredicate) (#$genlPreds #$mainProduct #$physicalParts) (#$arg1Isa #$mainProduct #$FormalProduct) (#$arg2Isa #$mainProduct #$Product) (#$comment #$mainProduct "The predicate #$mainProduct is used to identify the main item in a particular set of stuff that a customer gets when buying a packaged product. (#$mainProduct FORM PROD) means that the particular #$Product PROD is the main item of the #$FormalProduct FORM--as distinct from the accessories, agreements, packaging, literature, etc., that come along with it.") ;;; #$mainTransportees (#$isa #$mainTransportees #$BinaryPredicate) (#$genlPreds #$mainTransportees #$transportees) (#$arg1Isa #$mainTransportees #$TransportationEvent) (#$arg2Isa #$mainTransportees #$PartiallyTangible) (#$comment #$mainTransportees "(mainTransportees TRAN MT) means that MT is one of the main transportees, or of the primary things intended to be transported (as opposed to incidentals), in the instance TRAN of TransportationEvent.") ;;; #$majorUndertakingsOf (#$isa #$majorUndertakingsOf #$IrreflexiveBinaryPredicate) (#$isa #$majorUndertakingsOf #$AsymmetricBinaryPredicate) (#$isa #$majorUndertakingsOf #$ActorSlot) (#$genlPreds #$majorUndertakingsOf #$temporallyIntersects) (#$genlPreds #$majorUndertakingsOf #$performedBy) (#$arg1Isa #$majorUndertakingsOf #$Action) (#$arg2Isa #$majorUndertakingsOf #$Agent) (#$comment #$majorUndertakingsOf "(#$majorUndertakingsOf ACTION AGENT) means that AGENT consciously performed ACTION. The success and consequence(s) of ACTION are important to AGENT. As a result, for a sentient AGENT, failure usually results in AGENT feeling negative emotions, and success positive emotions.") ;;; #$makesProductType (#$isa #$makesProductType #$BinaryPredicate) (#$arg1Isa #$makesProductType #$CommercialOrganization) (#$arg2Isa #$makesProductType #$ProductType) (#$arg2Genl #$makesProductType #$Product) (#$comment #$makesProductType "The predicate #$makesProductType is used to indicate that a particular company makes a specific (i.e., type of) product. (#$makesProductType ORG PRODTYP) means that the #$CommercialOrganization ORG manufactures the #$ProductType PRODTYP. Cf. #$madeBy.") ;;; #$maleParentActor (#$isa #$maleParentActor #$IrreflexiveBinaryPredicate) (#$isa #$maleParentActor #$AntiTransitiveBinaryPredicate) (#$isa #$maleParentActor #$AsymmetricBinaryPredicate) (#$isa #$maleParentActor #$ActorSlot) (#$isa #$maleParentActor #$FunctionalSlot) (#$genlPreds #$maleParentActor #$parentActors) (#$arg1Isa #$maleParentActor #$BiologicalReproductionEvent) (#$arg2Isa #$maleParentActor #$Organism-Whole) (#$comment #$maleParentActor "(#$maleParentActor ?EVENT ?ORGANISM) means that ?ORGANISM is the male parent in the #$SexualReproductionEvent ?EVENT.") ;;; #$maleficiary (#$isa #$maleficiary #$BinaryPredicate) (#$genlPreds #$maleficiary #$preActors) (#$arg1Isa #$maleficiary #$Event) (#$arg2Isa #$maleficiary #$Agent) (#$comment #$maleficiary "(#$maleficiary ACT AGT) means that the #$Agent AGT is harmed by the occurrence of the action ACT. That is, the interest or welfare of AGT is thwarted, blocked, or harmed in ACT.") ;;; #$malleabilityOfObject (#$isa #$malleabilityOfObject #$TangibleObjectPredicate) (#$isa #$malleabilityOfObject #$IntervalBasedQuantitySlot) (#$arg1Isa #$malleabilityOfObject #$SolidTangibleThing) (#$arg2Isa #$malleabilityOfObject #$Malleability) (#$comment #$malleabilityOfObject "(#$malleabilityOfObject OBJ DEGREE) indicates that the instance of #$SolidTangibleThing OBJ has the degree of #$Malleability DEGREE.") ;;; #$maritalStatus (#$isa #$maritalStatus #$FunctionalSlot) (#$arg1Isa #$maritalStatus #$Person) (#$arg2Isa #$maritalStatus #$MaritalStatusOfPeople) (#$comment #$maritalStatus "(#$maritalStatus PRSN MSTAT) means #$Person PRSN has the #$MaritalStatusOfPeople MSTAT. The latter may be: #$Married, #$Widowed, #$Single, etc. E.g., (#$maritalStatus #$KeithRichards #$Married). The marital status of a person depends on whether, and when, that person was married to another person, and how the marriage ended.") ;;; #$massNumber (#$isa #$massNumber #$IntangibleObjectPredicate) (#$isa #$massNumber #$BinaryPredicate) (#$arg1Isa #$massNumber #$EnglishWord) (#$arg2Isa #$massNumber #$CharacterString) (#$comment #$massNumber "(#$massNumber WORD STRING) means that STRING is the mass noun form of WORD. For example, `paper' is the mass noun form of #$Paper-TheWord.") ;;; #$massOfObject (#$isa #$massOfObject #$PhysicalAttributeDescriptionSlot) (#$isa #$massOfObject #$PhysicalAmountSlot) (#$arg1Isa #$massOfObject #$PartiallyTangible) (#$arg2Isa #$massOfObject #$Mass) (#$comment #$massOfObject "(#$massOfObject OBJ MASS) means that the tangible object OBJ has #$Mass MASS.") ;;; #$mate (#$isa #$mate #$CotemporalObjectsSlot) (#$isa #$mate #$AntiTransitiveBinaryPredicate) (#$isa #$mate #$InterPersonalRelationSlot) (#$isa #$mate #$SymmetricBinaryPredicate) (#$not (#$isa #$mate #$TransitiveBinaryPredicate)) (#$genlPreds #$mate #$positiveVestedInterest) (#$genlPreds #$mate #$friends) (#$genlInverse #$mate #$mate) (#$arg1Isa #$mate #$Animal) (#$arg2Isa #$mate #$Animal) (#$comment #$mate "(#$mate ANIM1 ANIM2) means ANIM1 and ANIM2 mate (at least once) from time to time.") (#$comment #$mate "(#$mate PER1 PER2) means that PER1 and PER2 are long-term companions. More general in meaning than spouse, this can also be used to refer to one's `significant other(s)', including boyfriend(s), girlfriend(s), one's partner in a gay relationship, etc. The assumption in the #$HumanSocialLifeMt is that mates are bound together by relatively enduring emotional ties.") (#$comment #$mate "(mate PERSON1 PERSON2) means that PERSON1 and PERSON2 are mates and long-term monogamous companions. In the #$AngloAmericanSocialLifeMt each person has at most only one mate at a time. Hence, this predicate has #$SingleEntry arguments.") ;;; #$maxQuantValue (#$isa #$maxQuantValue #$RelationshipPredicate) (#$isa #$maxQuantValue #$ReflexiveBinaryPredicate) (#$arg1Isa #$maxQuantValue #$ScalarInterval) (#$arg2Isa #$maxQuantValue #$ScalarPointValue) (#$comment #$maxQuantValue "(#$maxQuantValue SCALAR POINT) means that the upper limit of the quantity SCALAR is POINT, an element of #$ScalarPointValue. SCALAR is an element of #$ScalarInterval. For example, the #$maxQuantValue for the pay of mail room employees might be (#$DollarsPerHour 6.5); e.g., (#$maxQuantValue `MailPay' (#$DollarsPerHour 6.5)). Another example: (#$maxQuantValue (#$Unity 5 10) 10).") ;;; #$maximalConnectedSubSystems (#$isa #$maximalConnectedSubSystems #$AntiSymmetricBinaryPredicate) (#$isa #$maximalConnectedSubSystems #$TransitiveBinaryPredicate) (#$genlPreds #$maximalConnectedSubSystems #$linkClosedSubSystems) (#$genlPreds #$maximalConnectedSubSystems #$pointClosedSubSystems) (#$arg1Isa #$maximalConnectedSubSystems #$Thing) (#$arg2Isa #$maximalConnectedSubSystems #$ConnectedPathSystem) (#$comment #$maximalConnectedSubSystems "(#$maximalConnectedSubSystems SYS SUB) means that SUB is a 'maximal' connected subsystem of SYS, i.e., that SUB is an entire connected piece of SYS without other disconnected pieces of SYS. That is to say, (i) SUB is a connected path system, and consequently must have at least one node, say NODE, in it, and (ii) SUB is a subsystem of SYS, and (iii) for every connected subsystem SUB1 of SYS containing NODE, SUB1 is a subsystem of SUB. Thus a maximal connected subsystem SUB of a path system SYS must satisfy the conditions that (a) for each point X in SUB and each point Y in SYS that is not in SUB, X and Y are not connected in SYS, and that (b) for any nodes X and Y in SUB, for any link LINK in SYS between X and Y, LINK must also be in SUB, and that (c) for each point X in SYS, if X is on a link in SYS which is also a link in SUB, then X must also be in SUB. It follows that if SUB is a maximal connected subsystem of SYS, SUB must be a link-closed subsystem as well as a point-closed subsystem of SYS. Another consequence is that if SUB is a maximal connected subsystem of SYS, and if X is a point in SUB and is on a loop in SYS, then the loop must also be in SUB.") ;;; #$measure (#$isa #$measure #$IntervalBasedQuantitySlot) (#$arg1Isa #$measure #$TemporalThing) (#$arg2Isa #$measure #$Time-Quantity) (#$comment #$measure "(#$measure ?X ?Y) indicates that ?Y is total elapsed time from the start of ?X to its end. For continuous #$TemporalThings, the #$measure of the object is the same as its #$duration (qv). But if the #$TemporalThing is discontinuous, then the #$measure will be greater than the #$duration. For example, `GeorgeWashingtonSleeping' has a #$measure that is about three times as long as its #$duration, assuming he slept about 8 hours a night. Note: Unfortunately, in some disciplines, such as Real Analysis, these two terms' definitions are switched! In such contexts, one could assert to Cyc that the preferred denotation of #$duration was #$Measure-TheWord, and that the preferred denotation of #$measure was #$Duration-TheWord, but notice that the two concepts --- #$measure and #$duration --- are still distinct and useful in that discipline, they just happen to have different names there.") ;;; #$mediators (#$isa #$mediators #$ActorSlot) (#$isa #$mediators #$AsymmetricBinaryPredicate) (#$isa #$mediators #$IrreflexiveBinaryPredicate) (#$genlPreds #$mediators #$socialParticipants) (#$arg1Isa #$mediators #$SocialOccurrence) (#$arg2Isa #$mediators #$Agent) (#$comment #$mediators "The facilitators of a process including the agents, brokers, or mediators that assist in arranging a contract, transaction, or agreement among several parties.") ;;; #$memberOfSpecies (#$isa #$memberOfSpecies #$FunctionalSlot) (#$genlPreds #$memberOfSpecies #$isa) (#$arg1Isa #$memberOfSpecies #$Organism-Whole) (#$arg2Isa #$memberOfSpecies #$BiologicalSpecies) (#$arg2Genl #$memberOfSpecies #$Organism-Whole) (#$comment #$memberOfSpecies "(#$memberOfSpecies ORG SPECIES) means that the organism ORG is a member of the #$BiologicalSpecies SPECIES.") ;;; #$memberOfThisPoliticalParty (#$isa #$memberOfThisPoliticalParty #$TaxonomicSlot) (#$genlPreds #$memberOfThisPoliticalParty #$hasMembers) (#$arg1Isa #$memberOfThisPoliticalParty #$PoliticalParty) (#$arg2Isa #$memberOfThisPoliticalParty #$HumanAdult) (#$comment #$memberOfThisPoliticalParty "(#$memberOfThisPoliticalParty PARTY PERS) means that #$Person PERS is a (registered) member of #$PoliticalParty PARTY. For example, (#$memberOfThisPoliticalParty #$DemocraticParty #$BillClinton).") ;;; #$middleName (#$isa #$middleName #$BinaryPredicate) (#$isa #$middleName #$IntangibleObjectPredicate) (#$genlPreds #$middleName #$nameOfAgent) (#$arg1Isa #$middleName #$Person) (#$arg2Isa #$middleName #$HumanGivenNameString) (#$comment #$middleName "(#$middleName X STRNG) means that #$Person X is known by the #$HumanGivenNameString STRNG as his or her middle name. E.g., (#$middleName #$Lenat ``Bruce''). A person rarely has more than one middle name. In some cultures, when a wedding occurs, one party changes their middle name to whatever their #$lastName used to be, thus leading to cases where the person's new middle name is actually a #$HumanFamilyNameString rather than a #$HumanGivenNameString --- the same is true in some cultures when an infant is born and given, as a middle name, the last name of a grandparent (other than the infant's last name).") ;;; #$minQuantValue (#$isa #$minQuantValue #$RelationshipPredicate) (#$isa #$minQuantValue #$ReflexiveBinaryPredicate) (#$arg1Isa #$minQuantValue #$ScalarInterval) (#$arg2Isa #$minQuantValue #$ScalarPointValue) (#$comment #$minQuantValue "(#$minQuantValue SCALAR POINT) means that the lower limit of SCALAR is POINT, an element of #$ScalarPointValue. SCALAR is an element of #$ScalarInterval. For example, the #$minQuantValue for the pay of mail room employees might be (#$DollarsPerHour 4.5); e.g., (#$minQuantValue `MailPay' (#$DollarsPerHour 4.5)). Another example: (#$minQuantValue (#$Unity 5 10) 5).") ;;; #$monetaryValue (#$isa #$monetaryValue #$IntervalBasedQuantitySlot) (#$arg1Isa #$monetaryValue #$SomethingExisting) (#$arg2Isa #$monetaryValue #$Money) (#$comment #$monetaryValue "The value of an element of #$SomethingExisting. For the time being, expressed in a monetary curency.") ;;; #$moneyTransferMode (#$isa #$moneyTransferMode #$BinaryPredicate) (#$arg1Isa #$moneyTransferMode #$MoneyTransfer) (#$arg2Isa #$moneyTransferMode #$MoneyTenderType) (#$arg2Genl #$moneyTransferMode #$TenderObject) (#$comment #$moneyTransferMode "(#$moneyTransferMode TRANSACTION TYPE) means that in some particular money transfer TRANSACTION, the #$MoneyTenderType used in that transaction was TYPE, e.g., #$CreditCard, #$Check-TenderObject, etc.") ;;; #$moneyTransferred (#$isa #$moneyTransferred #$Role) (#$isa #$moneyTransferred #$IntervalBasedQuantitySlot) (#$isa #$moneyTransferred #$CostBreakdownSlot) (#$arg1Isa #$moneyTransferred #$Buying) (#$arg1Isa #$moneyTransferred #$MoneyTransfer) (#$arg2Isa #$moneyTransferred #$Money) (#$comment #$moneyTransferred "This predicate indicates the amount of money involved in a particular transfer of funds. (#$moneyTransferred TRANS MONEY) means that MONEY is the quantity of #$Money transferred in the money transfer event TRANS. Note: MONEY is distinct from the physical #$TenderObjects (q.v.) used to accomplish that transfer (cf. #$objectTendered). For example, the #$moneyTransferred to pay a car payment might be the amount US$400, while the #$objectTendered in the paying is an instance of #$Check-TenderObject.") ;;; #$mother (#$isa #$mother #$AsymmetricBinaryPredicate) (#$isa #$mother #$CotemporalObjectsSlot) (#$isa #$mother #$AntiTransitiveBinaryPredicate) (#$isa #$mother #$FamilyRelationSlot) (#$not (#$isa #$mother #$TransitiveBinaryPredicate)) (#$genlPreds #$mother #$biologicalMother) (#$genlPreds #$mother #$cotemporal) (#$arg1Isa #$mother #$Animal) (#$arg2Isa #$mother #$FemaleAnimal) (#$comment #$mother "(#$mother CHILD MOM) means MOM is one of the persons who fulfill the role of mother for CHILD. This may or may not include CHILD's biological mother, and might include CHILD's step mother(s) or foster mother(s).") (#$comment #$mother "(#$mother OFFSPRING FEMALE) means that the #$FemaleAnimal FEMALE is the female biological parent of the #$Animal OFFSPRING .") ;;; #$mtInferenceFunction (#$isa #$mtInferenceFunction #$BinaryPredicate) (#$arg1Isa #$mtInferenceFunction #$Microtheory) (#$arg2Isa #$mtInferenceFunction #$CycSystemSymbol) (#$comment #$mtInferenceFunction "The function which is used to perform inference within this microtheory.") ;;; #$multiplicationUnits (#$isa #$multiplicationUnits #$TernaryPredicate) (#$isa #$multiplicationUnits #$BookkeepingPredicate) (#$arg1Isa #$multiplicationUnits #$UnitOfMeasure) (#$arg2Isa #$multiplicationUnits #$UnitOfMeasure) (#$arg3Isa #$multiplicationUnits #$UnitOfMeasure) (#$comment #$multiplicationUnits "The Cyc predicate #$multiplicationUnits is used to state what measurement units should be used for the product of two physical quantities, given the units measuring each of the quantities multiplied. (#$multiplicationUnits UM-1 UM-2 PROD-UM) means that the value of (#$TimesFn (UM-1 x) (UM-2 y)) should be given in the units PROD-UM. For example, (#$multiplicationUnits #$Mile #$Mile #$SquareMile). See also #$UnitOfMeasure, #$TimesFn.") ;;; #$myCreationTime (#$isa #$myCreationTime #$BinaryPredicate) (#$isa #$myCreationTime #$BookkeepingPredicate) (#$arg1Isa #$myCreationTime #$ReifiableTerm) (#$arg2Isa #$myCreationTime #$PositiveInteger) (#$comment #$myCreationTime "(#$myCreationTime X TIME) means that the constant X was created at time TIME. TIME is not, however, an instance of #$Date. This assertion is not intended for inference, only for documentation, so the format is a simple one, designed for human readability and for use by internal Cyc functions. The format of TIME is YYYYMMDD, so for example, 19870911 is September 11, 1987.") ;;; #$myCreator (#$isa #$myCreator #$BinaryPredicate) (#$isa #$myCreator #$BookkeepingPredicate) (#$arg1Isa #$myCreator #$ReifiableTerm) (#$arg2Isa #$myCreator #$Cyclist) (#$comment #$myCreator "(#$myCreator X Y) means that Y is the constant representing the person who introduced the constant X into the Cyc vocabulary. In general, the editing interfaces to the Cyc KB only allow the KB to be modified when an instance of #$Cyclist is designated as the author of the changes.") ;;; #$myEntity (#$isa #$myEntity #$FunctionalSlot) (#$isa #$myEntity #$InterExistingObjectSlot) (#$genlInverse #$myEntity #$subAbstrac) (#$arg1Isa #$myEntity #$SomethingExisting) (#$arg2Isa #$myEntity #$Entity) (#$comment #$myEntity "(#$myEntity ?X ?Y) indicates that ?Y is an #$Entity (qv) and that ?X is some subabstraction of ?Y. That is, (#$subAbstrac ?Y ?X). Note that each #$SomethingExisting ?X will generally have one unique #$Entity ?Y of which it is a #$subAbstrac. E.g., (#$myEntity AlbertEinsteinWhileAtPrinceton AlbertEinstein).") ;;; #$nameOfAgent (#$isa #$nameOfAgent #$IntangibleObjectPredicate) (#$isa #$nameOfAgent #$BinaryPredicate) (#$genlPreds #$nameOfAgent #$nameString) (#$arg1Isa #$nameOfAgent #$Agent) (#$arg2Isa #$nameOfAgent #$ProperNameString) (#$comment #$nameOfAgent "(#$nameOfAgent AGT STRING) means STRING is the name(s) of AGT. AGT can be a #$Person, #$Animal, #$Organization, etc. In most contexts, this means that AGT may normally be called STRING, in that context, and should therefore include their #$salutation if the context is a formal one, should omit their #$lastName if it is unambiguous and the context is an intimate one, etc..") ;;; #$nameString (#$isa #$nameString #$BinaryPredicate) (#$isa #$nameString #$IntangibleObjectPredicate) (#$arg1Isa #$nameString #$ReifiableTerm) (#$arg2Isa #$nameString #$ProperNameString) (#$comment #$nameString "(#$nameString THING STRING) means that the name of the thing THING is the string STRING. Use it to connect constants or NATS with their names. For agents, use the more specific predicate #$nameOfAgent.") (#$synonymousExternalConcept #$nameString #$SENSUS-Information1997 "NAME-RELATION") (#$synonymousExternalConcept #$nameString #$SENSUS-Information1997 "NAME-OF") ;;; #$nativeLanguage (#$isa #$nativeLanguage #$BinaryPredicate) (#$genlPreds #$nativeLanguage #$languageSpoken) (#$arg1Isa #$nativeLanguage #$Person) (#$arg2Isa #$nativeLanguage #$Language) (#$comment #$nativeLanguage "The first language spoken by a person. EntryFormat is #$SetTheFormat, to cover cases of bi-lingual childhoods.") ;;; #$near (#$isa #$near #$SymmetricBinaryPredicate) (#$isa #$near #$SpatialPredicate) (#$isa #$near #$IrreflexiveBinaryPredicate) (#$not (#$isa #$near #$TransitiveBinaryPredicate)) (#$genlInverse #$near #$near) (#$arg1Isa #$near #$SpatialThing) (#$arg2Isa #$near #$SpatialThing) (#$comment #$near "(#$near THIS THAT) means that the distance between THIS and THAT doesn't exceed the maximum dimension of the smaller object. Thus, two pebbles one mile apart would not be #$near each other, but a pebble one centimeter above the earth would be #$near the earth.") ;;; #$negationAttribute (#$isa #$negationAttribute #$IrreflexiveBinaryPredicate) (#$isa #$negationAttribute #$SymmetricBinaryPredicate) (#$not (#$isa #$negationAttribute #$TransitiveBinaryPredicate)) (#$genlInverse #$negationAttribute #$negationAttribute) (#$arg1Isa #$negationAttribute #$AttributeValue) (#$arg2Isa #$negationAttribute #$AttributeValue) (#$comment #$negationAttribute "(#$negationAttribute ATT1 ATT2) means that a thing cannot have both ATT1 and ATT2 as attributes at the same or overlapping times.") ;;; #$negationInverse (#$isa #$negationInverse #$IrreflexiveBinaryPredicate) (#$isa #$negationInverse #$SymmetricBinaryPredicate) (#$isa #$negationInverse #$RuleMacroPredicate) (#$not (#$isa #$negationInverse #$TransitiveBinaryPredicate)) (#$genlInverse #$negationInverse #$negationInverse) (#$arg1Isa #$negationInverse #$BinaryPredicate) (#$arg2Isa #$negationInverse #$BinaryPredicate) (#$comment #$negationInverse "The predicate #$negationInverse is used to describe a relationship between some elements of #$BinaryPredicate. (#$negationInverse PRED INV) means that if PRED holds between a pair of items (X,Y), then INV does NOT hold between the inverted pair (Y,X). In other words, #$negationInverse is syntactic shorthand for (#$implies (PRED X Y) (#$not (INV Y X))). Note that PRED and INV may take the same value; e.g., (#$negationInverse #$father #$father) is true and means that if X's #$father is Y, then X is NOT Y's #$father. Thus, #$negationInverse is true for all elements of #$AsymmetricBinaryPredicate.") ;;; #$negationPreds (#$isa #$negationPreds #$SymmetricBinaryPredicate) (#$isa #$negationPreds #$RuleMacroPredicate) (#$not (#$isa #$negationPreds #$TransitiveBinaryPredicate)) (#$genlInverse #$negationPreds #$negationPreds) (#$arg1Isa #$negationPreds #$Predicate) (#$arg2Isa #$negationPreds #$Predicate) (#$comment #$negationPreds "The predicate #$negationPreds is used to represent a relation between some elements of #$Predicate. (#$negationPreds PRED1 PRED2) means that PRED1 is a negation of PRED2 in the sense that any tuple in the extension of PRED1 is NOT also a tuple in the extension of PRED1. In other words, (#$negationPreds PRED1 PRED2) is shorthand for (#$implies (PRED1 {arg-list}) (#$not (PRED2 {arg-list}))). For example, (#$negationPreds #$transportees #$transporter).") ;;; #$negativeVestedInterest (#$not (#$isa #$negativeVestedInterest #$IrreflexiveBinaryPredicate)) (#$not (#$isa #$negativeVestedInterest #$ReflexiveBinaryPredicate)) (#$not (#$isa #$negativeVestedInterest #$TransitiveBinaryPredicate)) (#$isa #$negativeVestedInterest #$BinaryPredicate) (#$arg1Isa #$negativeVestedInterest #$Agent) (#$arg2Isa #$negativeVestedInterest #$TemporalThing) (#$comment #$negativeVestedInterest "(#$negativeVestedInterest AGT OBJ) means #$Agent AGT has a negative interest in the object OBJ or in the good fortune of OBJ, and a positive interest in its misfortune. Generally, AGT will be helped or pleased by the destruction, diminution, weakening, or retarding of OBJ, and will be hurt or displeased if OBJ is preserved or enhanced. See #$positiveVestedInterest.") ;;; #$nonDeliberateActors (#$isa #$nonDeliberateActors #$ActorSlot) (#$genlPreds #$nonDeliberateActors #$actors) (#$arg1Isa #$nonDeliberateActors #$Event) (#$arg2Isa #$nonDeliberateActors #$PartiallyTangible) (#$comment #$nonDeliberateActors "(#$nonDeliberateActors ACT ACTR) means that ACTR has a #$Role in the #$Event ACT but is not acting deliberately. Examples: (1) President #$JohnKennedy was a #$nonDeliberateActors in his assassination; (2) a person is a #$nonDeliberateActors in his/her own autonomic bodily functioning (e.g., heart beating, digesting); (3) Mount #$Vesuvius-Volcano was a #$nonDeliberateActors in the event of its eruption that destroyed Pompeii. #$nonDeliberateActors is a negative specification of the role an actor has in an event; the role of particular #$nonDeliberateActors might be further specified positively, e.g., with #$bodilyActedOn or #$bodilyDoer.") ;;; #$nonVolitionalResult-RST (#$isa #$nonVolitionalResult-RST #$RSTRelation) (#$isa #$nonVolitionalResult-RST #$AsymmetricBinaryPredicate) (#$arg1Isa #$nonVolitionalResult-RST #$LinguisticObject) (#$arg2Isa #$nonVolitionalResult-RST #$LinguisticObject) (#$comment #$nonVolitionalResult-RST "The discourse relation that holds between two segments of text when ARG1 specifies something which could be a nonvolitional cause of ARG2.") (#$synonymousExternalConcept #$nonVolitionalResult-RST #$SENSUS-Information1997 "RST-NONVOLITIONAL-RESULT") ;;; #$northOf (#$isa #$northOf #$TransitiveBinaryPredicate) (#$isa #$northOf #$AsymmetricBinaryPredicate) (#$arg1Isa #$northOf #$GeographicalRegion) (#$arg2Isa #$northOf #$GeographicalRegion) (#$comment #$northOf "(#$northOf REGION-1 REGION-2) means that the #$GeographicalRegion REGION-1 is to the north of the #$GeographicalRegion REGION-2, when viewed in the terrestrial frame of reference. Note that REGION-2 is therefore south of REGION-1; thus, no distinct predicate is needed to represent `south of'. Example: (#$northOf #$CityOfPhiladelphiaPA #$CityOfWashingtonDC).") ;;; #$northeastOf (#$isa #$northeastOf #$TransitiveBinaryPredicate) (#$isa #$northeastOf #$AsymmetricBinaryPredicate) (#$arg1Isa #$northeastOf #$GeographicalRegion) (#$arg2Isa #$northeastOf #$GeographicalRegion) (#$comment #$northeastOf "(#$northeastOf REGION-1 REGION-2) means that the #$GeographicalRegion REGION-1 is to the north-east of the #$GeographicalRegion REGION-2, when viewed in the terrestrial frame of reference. Note that REGION-2 is therefore southwest of REGION-1; thus, no distinct predicate is needed to represent `southwest of'. Example: (#$northeastOf #$Philippines #$Taiwan-RepublicOfChina).") ;;; #$northwestOf (#$isa #$northwestOf #$IrreflexiveBinaryPredicate) (#$isa #$northwestOf #$TransitiveBinaryPredicate) (#$isa #$northwestOf #$AsymmetricBinaryPredicate) (#$arg1Isa #$northwestOf #$GeographicalRegion) (#$arg2Isa #$northwestOf #$GeographicalRegion) (#$comment #$northwestOf "(#$northwestOf REGION-1 REGION-2) means that the #$GeographicalRegion REGION-1 is to the northwest of the #$GeographicalRegion REGION-2, when viewed in the terrestrial frame of reference. Note that REGION-2 is therefore southeast of REGION-1; thus, no distinct predicate is needed to represent `southeast of'. Example: (#$northwestOf #$UnitedKingdomOfGreatBritainAndNorthernIreland #$France).") ;;; #$not (#$isa #$not #$LogicalConnective) (#$isa #$not #$Relationship) (#$arg1Isa #$not #$CycFormula) (#$comment #$not "The predicate #$not is the negation operator in Cyc. #$not takes a single element of #$CycFormula as its argument. (#$not FORM) is true if and only if the formula FORM is false in Cyc.") ;;; #$notices (#$isa #$notices #$PropositionalAttitudeSlot) (#$genlPreds #$notices #$beliefs) (#$arg1Isa #$notices #$IntelligentAgent) (#$arg2Isa #$notices #$CycFormula) (#$comment #$notices "(#$notices AGT PROP) means that AGT believes the proposition PROP because AGT has seen, heard, smelled, etc. PROP via some element of #$Perceiving. Although (#$notices AGT PROP) implies (#$beliefs AGT PROP) {via the assertion (#$genlPreds #$notices #$beliefs)}, exceptions occur if AGT believes they have been hallucinating or drugged, for example. The predicate #$beliefs, unlike #$notices, can include propositions gathered through inferring, dreaming, intuiting. The temporal extent of (#$notices AGT PROP) is at least a 'short time' following the perceiving of PROP. The extent of this time is a function of the type of fact perceived noticed, when forgetting or other overriding information comes into play.") ;;; #$numInhabitants (#$isa #$numInhabitants #$IntervalBasedQuantitySlot) (#$isa #$numInhabitants #$IntangibleObjectPredicate) (#$arg1Isa #$numInhabitants #$GeographicalRegion) (#$arg1Isa #$numInhabitants #$Agent) (#$arg2Isa #$numInhabitants #$Integer) (#$comment #$numInhabitants "The predicate #$numInhabitants is used to indicate the number of people living in a region. (#$numInhabitants REGION NUMBER) means that the #$GeographicalAgent REGION has this #$Integer NUMBER of inhabitants. Note that, for any particular country, NUMBER is not necessarily the same as the number of its citizens, since citizens may be living abroad, and aliens may be residing in the country. Examples: (#$numInhabitants #$CityOfRomeItaly 2800000); (#$numInhabitants #$CityOfTokyoJapan 8300000).") ;;; #$numericallyEqual (#$isa #$numericallyEqual #$TransitiveBinaryPredicate) (#$isa #$numericallyEqual #$ReflexiveBinaryPredicate) (#$isa #$numericallyEqual #$SymmetricBinaryPredicate) (#$isa #$numericallyEqual #$EvaluatableFunction) (#$isa #$numericallyEqual #$NumericComparison) (#$genlInverse #$numericallyEqual #$numericallyEqual) (#$arg1Isa #$numericallyEqual #$ScalarInterval) (#$arg2Isa #$numericallyEqual #$ScalarInterval) (#$comment #$numericallyEqual "The predicate #$numericallyEqual is Cyc's representation of the equals ( = ) of arithmetic, adapted to use with Cyc's scalars, which include quantitative intervals as well as point values. For any two instances of #$ScalarInterval, (#$numericallyEqual SI-1 SI-2) means that the minimum of SI-1 is equal to the mininum of SI-2 and that the maximum of SI-1 is equal to the maximum of SI-2. See also #$ScalarInterval.") (#$synonymousExternalConcept #$numericallyEqual #$SENSUS-Information1997 "EXACTLY") ;;; #$objectActedOn (#$isa #$objectActedOn #$IrreflexiveBinaryPredicate) (#$isa #$objectActedOn #$ActorSlot) (#$isa #$objectActedOn #$AsymmetricBinaryPredicate) (#$genlPreds #$objectActedOn #$preActors) (#$arg1Isa #$objectActedOn #$Event) (#$arg2Isa #$objectActedOn #$SomethingExisting) (#$comment #$objectActedOn "The predicate #$objectActedOn is used to relate an event to an entity (or entities) significantly affected in that event. That entity must exist before the event, but may be either destroyed in the event (see #$inputsDestroyed), or merely affected by it (e.g., see #$damages, #$objectOfStateChange). (#$objectActedOn EVENT OBJECT) means that OBJECT is altered or affected in EVENT, and the change that OBJECT undergoes is central or focal to understanding EVENT. Thus, scissors are NOT an #$objectActedOn in a #$HairCuttingEvent. The focal change in a haircut is hair getting shorter; thus, hair is a legitimate #$objectActedOn in a #$HairCuttingEvent. The almost microscopic dulling that scissors undergo in a single haircut is a comparatively insignificant change with respect to a single haircut, considered as a #$HairCuttingEvent. Note: long-term effects of usage on devices should be axiomatized in connection with #$UsingAFn constants.") (#$synonymousExternalConcept #$objectActedOn #$SENSUS-Information1997 "ACTEE") ;;; #$objectControlled (#$isa #$objectControlled #$AsymmetricBinaryPredicate) (#$isa #$objectControlled #$ActorSlot) (#$genlPreds #$objectControlled #$objectActedOn) (#$arg1Isa #$objectControlled #$ControllingSomething) (#$arg2Isa #$objectControlled #$PartiallyTangible) (#$comment #$objectControlled "This predicate is used to indicate that a particular object is being controlled in a particular event. (#$objectControlled EVENT OBJ) means that the object OBJ is being controlled in the #$Event EVENT. Note: #$objectControlled does not assume or require physical contact between controller and object controlled.") ;;; #$objectEmitted (#$isa #$objectEmitted #$ActorSlot) (#$isa #$objectEmitted #$AsymmetricBinaryPredicate) (#$genlPreds #$objectEmitted #$objectMoving) (#$arg1Isa #$objectEmitted #$EmittingAnObject) (#$arg2Isa #$objectEmitted #$PartiallyTangible) (#$comment #$objectEmitted "This predicate is used in connection with particular instances of #$EmittingAnObject, to identify the object which `comes out' during the event. (#$objectEmitted EMIT OBJ) means that OBJ is emitted from the #$emitter during the emission event EMIT. The #$objectEmitted is also an #$objectMoving in EMIT. For example, in a particular human #$BirthEvent, some particular #$HumanInfant is an #$objectEmitted.") ;;; #$objectFoundInLocation (#$isa #$objectFoundInLocation #$ReflexiveBinaryPredicate) (#$isa #$objectFoundInLocation #$TransitiveBinaryPredicate) (#$isa #$objectFoundInLocation #$CotemporalObjectsSlot) (#$not (#$isa #$objectFoundInLocation #$SymmetricBinaryPredicate)) (#$not (#$isa #$objectFoundInLocation #$AntiSymmetricBinaryPredicate)) (#$not (#$isa #$objectFoundInLocation #$AsymmetricBinaryPredicate)) (#$genlPreds #$objectFoundInLocation #$inRegion) (#$genlPreds #$objectFoundInLocation #$cotemporal) (#$arg1Isa #$objectFoundInLocation #$PartiallyTangible) (#$arg2Isa #$objectFoundInLocation #$SpatialThing) (#$comment #$objectFoundInLocation "(#$objectFoundInLocation OBJ LOC) means that OBJ has the location LOC. OBJ is not a part of LOC. Examples: the #$ArcDeTriomphe is located in the #$CityOfParisFrance; the #$AlaskanPipeline is found in #$Alaska-State; the #$TownOfGettysburgPA is located in the Eastern region of Pennsylvania (note that the town's territory is part of Pennsylvania, but the town as a social organization is distinct). See also the #$comment on #$inRegion. Cf., for cases where OBJ is a spatial part of LOC, #$physicalDecompositions, #$geographicalSubRegions.") ;;; #$objectMoving (#$isa #$objectMoving #$ActorSlot) (#$isa #$objectMoving #$AsymmetricBinaryPredicate) (#$genlPreds #$objectMoving #$transferredThing) (#$genlPreds #$objectMoving #$temporallyIntersects) (#$arg1Isa #$objectMoving #$MovementEvent) (#$arg2Isa #$objectMoving #$PartiallyTangible) (#$comment #$objectMoving "The predicate #$objectMoving is used to refer to an object which is moving in a particular #$MovementEvent. (#$objectMoving MOVE OBJECT) means that OBJECT is in motion at some point during the #$MovementEvent MOVE and this movement is focal in MOVE. In some cases, such as an instance of #$LocomotionEvent, OBJECT causes MOVE directly. OBJECT's motion in MOVE may be translational, rotational, or some combination of these. OBJECT may be a solid -- such as an animal, an automobile, or a tennis ball -- or a fluid, such as lava flowing or a warm air mass rising.") ;;; #$objectOfPossessionTransfer (#$isa #$objectOfPossessionTransfer #$ActorSlot) (#$isa #$objectOfPossessionTransfer #$AsymmetricBinaryPredicate) (#$genlPreds #$objectOfPossessionTransfer #$transferredThing) (#$arg1Isa #$objectOfPossessionTransfer #$ChangeInUserRights) (#$arg2Isa #$objectOfPossessionTransfer #$SomethingExisting) (#$comment #$objectOfPossessionTransfer "The predicate #$objectOfPossessionTransfer identifies the object which `changes hands' in a particular event wherein some user's rights to it are changed. (#$objectOfPossessionTransfer EVENT OBJECT) means that in EVENT, all or some rights to use OBJECT are transferred from one agent (the #$fromPossessor) to another (the #$toPossessor). EVENT is an element of #$ChangeInUserRights (q.v.), for example, a buying, renting, lending, repossessing, etc.") ;;; #$objectOfStateChange (#$isa #$objectOfStateChange #$ActorSlot) (#$isa #$objectOfStateChange #$AsymmetricBinaryPredicate) (#$isa #$objectOfStateChange #$AntiTransitiveBinaryPredicate) (#$genlPreds #$objectOfStateChange #$objectActedOn) (#$genlPreds #$objectOfStateChange #$postActors) (#$arg1Isa #$objectOfStateChange #$IntrinsicStateChangeEvent) (#$arg2Isa #$objectOfStateChange #$PartiallyTangible) (#$comment #$objectOfStateChange "The predicate #$objectOfStateChange is used to identify the object of an instance of #$IntrinsicStateChangeEvent. (#$objectOfStateChange EVENT OBJECT) means that OBJECT is an #$Entity that undergoes some kind of intrinsic change of state in EVENT. OBJECT exists before EVENT, is directly involved in EVENT, and persists after EVENT. (Accordingly, this predicate inherits the #$genlPreds #$preActors and #$postActors through #$objectActedOn.) The change which OBJECT undergoes is internal or intrinsic; this predicate is not used for extrinsic changes, e.g., in location, orientation, ownership, status, etc. Note: If OBJECT were destroyed by EVENT and went out of existence in the course of EVENT, then the right predicate to use would be #$inputsDestroyed, rather than #$objectOfStateChange.") ;;; #$objectPaidFor (#$isa #$objectPaidFor #$ActorSlot) (#$genlPreds #$objectPaidFor #$objectOfPossessionTransfer) (#$arg1Isa #$objectPaidFor #$MonetaryExchangeOfUserRights) (#$arg2Isa #$objectPaidFor #$SomethingExisting) (#$comment #$objectPaidFor "(#$objectPaidFor EVENT OBJECT) means that in the #$MonetaryExchangeOfUserRights EVENT, the right to possess OBJECT is transferred from one #$Agent to another. OBJ is not the #$objectTendered but the goods that are bought or rented.") ;;; #$objectRemoved (#$isa #$objectRemoved #$ActorSlot) (#$isa #$objectRemoved #$AsymmetricBinaryPredicate) (#$genlPreds #$objectRemoved #$objectMoving) (#$genlPreds #$objectRemoved #$objectActedOn) (#$genlPreds #$objectRemoved #$postActors) (#$arg1Isa #$objectRemoved #$RemovingSomething) (#$arg2Isa #$objectRemoved #$PartiallyTangible) (#$comment #$objectRemoved "(#$objectRemoved REMOVING OBJ) means OBJ is removed from its previous location in the removing event REMOVING. The force that does the REMOVING comes from some other object than OBJ.") ;;; #$objectSelected (#$isa #$objectSelected #$ActorSlot) (#$isa #$objectSelected #$FunctionalSlot) (#$genlPreds #$objectSelected #$actors) (#$arg1Isa #$objectSelected #$PurposefulAction) (#$arg1Isa #$objectSelected #$HumanActivity) (#$arg2Isa #$objectSelected #$Individual) (#$comment #$objectSelected "(#$objectSelected SEL OBJ) means that OBJ is the object that is chosen in the event SEL, an instance of #$SelectingSomething. If what is selected in SEL is a collection, rather than an individual object, then use the predicate #$activityObjectType to represent the object of SEL.") ;;; #$objectTakenCareOf (#$isa #$objectTakenCareOf #$ActorSlot) (#$isa #$objectTakenCareOf #$AsymmetricBinaryPredicate) (#$isa #$objectTakenCareOf #$IrreflexiveBinaryPredicate) (#$genlPreds #$objectTakenCareOf #$objectActedOn) (#$genlPreds #$objectTakenCareOf #$postActors) (#$arg1Isa #$objectTakenCareOf #$PurposefulAction) (#$arg1Isa #$objectTakenCareOf #$ActionOnObject) (#$arg1Isa #$objectTakenCareOf #$HumanActivity) (#$arg2Isa #$objectTakenCareOf #$SomethingExisting) (#$comment #$objectTakenCareOf "(#$objectTakenCareOf EV OBJ) means that OBJ is acted on in EV by some #$Agent in order to maintain, preserve, or promote the health or good condition of OBJ.") ;;; #$objectTendered (#$isa #$objectTendered #$IrreflexiveBinaryPredicate) (#$isa #$objectTendered #$AsymmetricBinaryPredicate) (#$isa #$objectTendered #$ActorSlot) (#$genlPreds #$objectTendered #$objectOfPossessionTransfer) (#$arg1Isa #$objectTendered #$MoneyTransfer) (#$arg2Isa #$objectTendered #$TenderObject) (#$comment #$objectTendered "This predicate indicates the financial instrument which is used in a particular transfer of money. (#$objectTendered TRANS OBJECT) means that the #$TenderObject OBJECT is used to transfer funds in the #$MoneyTransfer event TRANS. See also #$TenderObject. Note: OBJECT is distinct from the quantity of #$Money transferred (see #$moneyTransferred) although of course OBJECT has some value --- is `worth' a certain amount, generally calculated from the numbers printed or stamped or engraved on the #$TenderObject OBJECT --- which in turn is an element of #$Money.") ;;; #$objectTested (#$isa #$objectTested #$AsymmetricBinaryPredicate) (#$genlPreds #$objectTested #$objectActedOn) (#$arg1Isa #$objectTested #$PurposefulAction) (#$arg1Isa #$objectTested #$Thinking) (#$arg2Isa #$objectTested #$PartiallyTangible) (#$comment #$objectTested "(#$objectTested EVAL OBJ) mean that OBJ is the specific object or portion being tested in EVAL. For example, if someone has a blood test, then the object tested is the portion of blood used to run the test fulfulls the role of #$objectTested, rather than the person or the collection of that person's blood.") ;;; #$objectsInContact (#$isa #$objectsInContact #$TernaryPredicate) (#$isa #$objectsInContact #$Role) (#$arg1Isa #$objectsInContact #$PhysicalContactSituation) (#$arg2Isa #$objectsInContact #$PartiallyTangible) (#$arg3Isa #$objectsInContact #$PartiallyTangible) (#$comment #$objectsInContact "The predicate #$objectsInContact indicates that two objects physically touch in a particular #$PhysicalContactSituation. (#$objectsInContact SIT OBJ-1 OBJ-2) means that OBJ-1 and OBJ-2 are in contact in the #$PhysicalContactSituation SIT. For example, a #$ClothingItem and its #$wearer are #$objectsInContact during the wearing. A father and son in a #$CarryingPiggyback event are #$objectsInContact. (#$objectsInContact SIT OBJ-1 OBJ-2) entails (#$holdsIn SIT (#$touches OBJ-1 OBJ-2)); #$touches covers both direct touching and touching indirectly (i.e., through a thin layer, e.g., through clothing).") ;;; #$obscuresFrom (#$isa #$obscuresFrom #$TernaryPredicate) (#$arg1Isa #$obscuresFrom #$PartiallyTangible) (#$arg2Isa #$obscuresFrom #$PartiallyTangible) (#$arg3Isa #$obscuresFrom #$Agent) (#$comment #$obscuresFrom "(obscuresFrom OBJ1 OBJ2 OBJ3) means that OBJ1 visually blocks OBJ2 from OBJ3's view.") ;;; #$occurrencesPerPeriod (#$isa #$occurrencesPerPeriod #$TernaryPredicate) (#$arg1Isa #$occurrencesPerPeriod #$TemporalObjectType) (#$arg2Isa #$occurrencesPerPeriod #$TemporalObjectType) (#$arg3Isa #$occurrencesPerPeriod #$Integer) (#$comment #$occurrencesPerPeriod "(#$occurrencesPerPeriod ?X ?Y ?N) indicates that ?N instances of ?X occur during each instance of ?Y. For example, to indicate that there are seven calendar days in each calendar week, we would write the axiom (#$occurrencesPerPeriod #$CalendarDay #$CalendarWeek 7).") ;;; #$officiator (#$isa #$officiator #$IrreflexiveBinaryPredicate) (#$isa #$officiator #$AsymmetricBinaryPredicate) (#$isa #$officiator #$ActorSlot) (#$genlPreds #$officiator #$socialParticipants) (#$arg1Isa #$officiator #$SocialOccurrence) (#$arg2Isa #$officiator #$Agent) (#$comment #$officiator "The predicate #$officiator points to the agent who performs official functions at an event. For example, it is used to indicate the person who plays the role of a priest or justice of the peace at a wedding; also, a master of ceremonies, a judge, a referee. An #$officiator is one of the performers at the social event where s/he officiates, usually not the only one.") ;;; #$offspringActors (#$isa #$offspringActors #$ActorSlot) (#$genlPreds #$offspringActors #$outputsCreated) (#$arg1Isa #$offspringActors #$BiologicalReproductionEvent) (#$arg2Isa #$offspringActors #$BiologicalLivingObject) (#$comment #$offspringActors "(#$offspringActors EVENT ORGANISM) means that ORGANISM is an offspring created in the #$BiologicalReproductionEvent EVENT .") ;;; #$oilSolubility (#$isa #$oilSolubility #$IntervalBasedQuantitySlot) (#$isa #$oilSolubility #$TangibleObjectPredicate) (#$isa #$oilSolubility #$PhysicalAttributeDescriptionSlot) (#$arg1Isa #$oilSolubility #$PartiallyTangible) (#$arg2Isa #$oilSolubility #$Solubility) (#$comment #$oilSolubility "(#$oilSolubility OBJ DEGREE) means that the particular tangible OBJ has this DEGREE of #$Solubility in #$Oil.") ;;; #$oldConstantName (#$isa #$oldConstantName #$BinaryPredicate) (#$arg1Isa #$oldConstantName #$Thing) (#$arg2Isa #$oldConstantName #$CycSystemString) (#$comment #$oldConstantName "If this constant has been renamed after Oct 95, and if the system variable cyc::*note-old-constant-name* is set to t on the machine on which the name change occurred, then this slot automatically records the most recent name that this constant had.") ;;; #$on-Physical (#$not (#$isa #$on-Physical #$AsymmetricBinaryPredicate)) (#$isa #$on-Physical #$IrreflexiveBinaryPredicate) (#$isa #$on-Physical #$SpatialPredicate) (#$not (#$isa #$on-Physical #$TransitiveBinaryPredicate)) (#$not (#$isa #$on-Physical #$SymmetricBinaryPredicate)) (#$not (#$isa #$on-Physical #$AntiSymmetricBinaryPredicate)) (#$genlPreds #$on-Physical #$above-Touching) (#$genlPreds #$on-Physical #$supportedBy) (#$arg1Isa #$on-Physical #$PartiallyTangible) (#$arg2Isa #$on-Physical #$PartiallyTangible) (#$comment #$on-Physical "(#$on-Physical OVER UNDER) means that the object OVER is above, supported by, and touching the object UNDER. OVER and UNDER may be at rest or in motion, or one may be in motion and the other at rest (relative to it). Examples: a person on a bicycle; groceries on a checkout conveyor belt; a statue on a pedestal. Note that only #$touches (and not #$touchesDirectly) is implied.") ;;; #$onLine (#$isa #$onLine #$BinaryPredicate) (#$isa #$onLine #$SpatialPredicate) (#$genlPreds #$onLine #$spatiallyIntersects) (#$arg1Isa #$onLine #$SpatialThing) (#$arg2Isa #$onLine #$Line) (#$comment #$onLine "(#$onLine OBJ LINE) means that OBJ is an object or region with one or more dimensions much smaller than the length of the #$Line LINE, and OBJ #$spatiallyIntersects or touches LINE but does not include all of LINE. One object can be on several different #$Lines. See also #$onPath and #$onPath-Generic.") ;;; #$onPath (#$isa #$onPath #$TransitiveBinaryPredicate) (#$isa #$onPath #$IrreflexiveBinaryPredicate) (#$isa #$onPath #$CotemporalObjectsSlot) (#$genlPreds #$onPath #$objectFoundInLocation) (#$genlPreds #$onPath #$cotemporal) (#$genlPreds #$onPath #$onPath-Generic) (#$arg1Isa #$onPath #$PartiallyTangible) (#$arg2Isa #$onPath #$Path-Simple) (#$comment #$onPath "(#$onPath ARG1 PATH) means that ARG1 is located along (on or adjacent to) the #$Path-Generic PATH. ARG1 could be a moving object or it could be a stationary point (see the more specific predicate #$pointOnPath) For example, Saint Louis, Missouri was #$onPath U.S. Route 66, as was Missouri, any car driving along it, and any lamp-post on it.") ;;; #$onPath-Generic (#$isa #$onPath-Generic #$BinaryPredicate) (#$arg1Isa #$onPath-Generic #$PartiallyTangible) (#$arg2Isa #$onPath-Generic #$Path-Generic) (#$comment #$onPath-Generic "(onPath-Generic LOC PATH) means that LOC, a location, is on the path PATH. Here at least a part of LOC should be a part of PATH (e.g., as a part of the meaning of the sentence that Austin is on I35, a part of Austin is a part of I35). Note that #$onPath-Generic is used for #$Path-Generic. If one wants to be clear that the path PATH is an instance of #$Path-Simple, then #$onPath rather than #$onPath-Generic should be used.") ;;; #$opinions (#$isa #$opinions #$PropositionalAttitudeSlot) (#$genlPreds #$opinions #$beliefs) (#$arg1Isa #$opinions #$IntelligentAgent) (#$arg2Isa #$opinions #$CycFormula) (#$comment #$opinions "(#$opinions AGT PROP) means that the #$Agent AGT believes that PROP (represented by a #$CycFormula) may be true, but they aren't sure about it, their mind might be changed, they are usually aware that PROP is just an opinion, etc. They may or may not have an argument to justify PROP. Note: Opinion implies belief. So if (#$opinions AGT PROP), then (#$beliefs AGT PROP) is true. Note: Opinion and knowledge are mutually exclusive: if (#$knows AGT PROP), then it is NOT true that (#$opinions AGT PROP).")